ASM-16bit Zufallszahlen ohne Wiederholung

MADS

ct, count, copyfrom, test sind alles zeropage words t_rand ist die Tabelle, wo die 16bit Werte abgelegt werden (also ist sie am Ende exakt doppelt so groß, we man Zahlen haben möchte.

  .zpvar  .word count,copyfrom,ct,test

  .proc gen_zufall  ;800 16bit Zufallszahlen ohne Wiederholung erstellen
  mwa #0 count
  .local gen_rand16
  lda random
  sta copyfrom
@ lda random
  and #$f
  cmp #4
  bcs @-
  sta copyfrom+1
  cpw copyfrom #800 ;gewünschte maximale Zahl
  bcs gen_rand16
;--- Test ob schon eingeschrieben in unserer Tabelle
  mwa #0 ct
  mwa #t_rand test
lp  ldy #1
  lda copyfrom+1
  cmp (test),y
  bcc next  ;kleiner
  bne next  ;größer
  dey
  lda copyfrom
  cmp (test),y
  beq gen_rand16  ;gleich -> neue Zahl erstellen
next  inw ct
  adw test #2
  cpw count ct
  bcs lp
;---
set lda copyfrom
chg sta t_rand
  lda copyfrom+1
chg1  sta t_rand+1
  inw count
  adw chg+1 #2
  adw chg1+1 #2
  cpw count #799  ;gewünschte Anzahl-1
  jcc gen_rand16
  .endl
  rts
  .endp
;---
t_rand
  .ds 1600

Warnung! Die Routine funktioniert, aber ES DAUERT. Ich nutze daher für mein Projekt eine am PC erstellte Liste, die dann halt nicht so ganz zufällig ist, für den Zweck ausreicht und halt sofort geht. Ich benötigte exakt 800 Zahlen, zufällig und alle von 0 bis 799. Wenn Ihr nur einfach Zufallszahlen benötigt, die sich nicht wiederholen, kann das:

  and #$f
  cmp #4
  bcs @-

und auch das:

  cpw copyfrom #800 ;gewünschte maximale Zahl
  bcs gen_rand16

weggelassen werden. Wo doppelte Zahlen kein Problem sind, einfach alles zwischen den beiden ";---" weglassen. Dann ist das auch echt schnell.

Für meinen speziellen Fall habe ich einen falschen Ansatz gehabt. Ich will ja exakt 800 Zahlen von 0 bis 799 zufällig haben. Da kann ich ja einfach eine sortierte Tabelle von 0 bis 799 zufällig x mal durchtauschen und es sollte dann auch nicht mehr so lange dauern...

Im Listing oben muss man ja ewig suchen, ob die Zahl schon vorhanden ist. Manchmal ist der erste Ansatz nicht immer der Beste 🤣

Wenn man natürlich z. B. eine Liste mit 100 Zahlen haben möchte, im Bereich von 0 bis 799 ohne Dopplung, ist obige Routine wohl die Wahl. Dort sind dann ja nicht alle 800 möglichen Zahlen drin.

So, hier der Code zu der oben skizzierten Idee. Es ist wirklich "geringfügig" schneller 😂

  .zpvar  .word copyfrom,copyto,ct,test,test2

  .local gen_table
  mwa #0 ct
  mwa #t_rand test
lp  ldy #0
  lda ct
  sta (test),y
  iny
  lda ct+1
  sta (test),y
  inw ct
:2  inw test
  cpw ct #800
  bne lp
  .endl
;---
  .local shuffle
  mwa #0 ct
start
;--- generate 2 numbers to change
gen_rand16_1
  lda random
  sta test
@ lda random
  and #$f
  cmp #4
  bcs @-
  sta test+1
  cpw test #800
  bcs gen_rand16_1
gen_rand16_2
  lda random
  sta test2
@ lda random
  and #$f
  cmp #4
  bcs @-
  sta test2+1
  cpw test2 #800
  bcs gen_rand16_2
  cpw test test2
  beq gen_rand16_2
;--- multiply by 2 as table is a word table
  clc
  rol test
  rol test+1
  clc
  rol test2
  rol test2+1
;--- change
  adw test #t_rand copyfrom
  adw test2 #t_rand copyto
  ldy #0
lo  mva (copyfrom),y test
  mva (copyto),y (copyfrom),y
  mva test (copyto),y
  iny
hi  mva (copyfrom),y test
  mva (copyto),y (copyfrom),y
  mva test (copyto),y
  inw ct
  cpw ct #800 ;wir würfeln jetzt einfach auch 800 mal das Feld durch
  jne start
  .endl